{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Image Captioning with LSTMs\n",
    "In the previous exercise you implemented a vanilla RNN and applied it to image captioning. In this notebook you will implement the LSTM update rule and use it for image captioning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "import time, os, json\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.rnn_layers import *\n",
    "from cs231n.captioning_solver import CaptioningSolver\n",
    "from cs231n.classifiers.rnn import CaptioningRNN\n",
    "from cs231n.coco_utils import load_coco_data, sample_coco_minibatch, decode_captions\n",
    "from cs231n.image_utils import image_from_url\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load MS-COCO data\n",
    "As in the previous notebook, we will use the Microsoft COCO dataset for captioning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "base dir  E:\\internship\\code\\cs231n\\assignment3_jupyter\\assignment3\\cs231n\\datasets/coco_captioning\n",
      "train_captions <class 'numpy.ndarray'> (400135, 17) int32\n",
      "train_image_idxs <class 'numpy.ndarray'> (400135,) int32\n",
      "val_captions <class 'numpy.ndarray'> (195954, 17) int32\n",
      "val_image_idxs <class 'numpy.ndarray'> (195954,) int32\n",
      "train_features <class 'numpy.ndarray'> (82783, 512) float32\n",
      "val_features <class 'numpy.ndarray'> (40504, 512) float32\n",
      "idx_to_word <class 'list'> 1004\n",
      "word_to_idx <class 'dict'> 1004\n",
      "train_urls <class 'numpy.ndarray'> (82783,) <U63\n",
      "val_urls <class 'numpy.ndarray'> (40504,) <U63\n"
     ]
    }
   ],
   "source": [
    "# Load COCO data from disk; this returns a dictionary\n",
    "# We'll work with dimensionality-reduced features for this notebook, but feel\n",
    "# free to experiment with the original features by changing the flag below.\n",
    "data = load_coco_data(pca_features=True)\n",
    "\n",
    "# Print out all the keys and values from the data dictionary\n",
    "for k, v in data.items():\n",
    "    if type(v) == np.ndarray:\n",
    "        print(k, type(v), v.shape, v.dtype)\n",
    "    else:\n",
    "        print(k, type(v), len(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM\n",
    "If you read recent papers, you'll see that many people use a variant on the vanilla RNN called Long-Short Term Memory (LSTM) RNNs. Vanilla RNNs can be tough to train on long sequences due to vanishing and exploding gradients caused by repeated matrix multiplication. LSTMs solve this problem by replacing the simple update rule of the vanilla RNN with a gating mechanism as follows.\n",
    "\n",
    "Similar to the vanilla RNN, at each timestep we receive an input $x_t\\in\\mathbb{R}^D$ and the previous hidden state $h_{t-1}\\in\\mathbb{R}^H$; the LSTM also maintains an $H$-dimensional *cell state*, so we also receive the previous cell state $c_{t-1}\\in\\mathbb{R}^H$. The learnable parameters of the LSTM are an *input-to-hidden* matrix $W_x\\in\\mathbb{R}^{4H\\times D}$, a *hidden-to-hidden* matrix $W_h\\in\\mathbb{R}^{4H\\times H}$ and a *bias vector* $b\\in\\mathbb{R}^{4H}$.\n",
    "\n",
    "At each timestep we first compute an *activation vector* $a\\in\\mathbb{R}^{4H}$ as $a=W_xx_t + W_hh_{t-1}+b$. We then divide this into four vectors $a_i,a_f,a_o,a_g\\in\\mathbb{R}^H$ where $a_i$ consists of the first $H$ elements of $a$, $a_f$ is the next $H$ elements of $a$, etc. We then compute the *input gate* $g\\in\\mathbb{R}^H$, *forget gate* $f\\in\\mathbb{R}^H$, *output gate* $o\\in\\mathbb{R}^H$ and *block input* $g\\in\\mathbb{R}^H$ as\n",
    "\n",
    "$$\n",
    "i = \\sigma(a_i) \\hspace{2pc}\n",
    "f = \\sigma(a_f) \\hspace{2pc}\n",
    "o = \\sigma(a_o) \\hspace{2pc}\n",
    "g = \\tanh(a_g)\n",
    "$$\n",
    "\n",
    "where $\\sigma$ is the sigmoid function and $\\tanh$ is the hyperbolic tangent, both applied elementwise.\n",
    "\n",
    "Finally we compute the next cell state $c_t$ and next hidden state $h_t$ as\n",
    "\n",
    "$$\n",
    "c_{t} = f\\odot c_{t-1} + i\\odot g \\hspace{4pc}\n",
    "h_t = o\\odot\\tanh(c_t)\n",
    "$$\n",
    "\n",
    "where $\\odot$ is the elementwise product of vectors.\n",
    "\n",
    "In the rest of the notebook we will implement the LSTM update rule and apply it to the image captioning task. \n",
    "\n",
    "In the code, we assume that data is stored in batches so that $X_t \\in \\mathbb{R}^{N\\times D}$, and will work with *transposed* versions of the parameters: $W_x \\in \\mathbb{R}^{D \\times 4H}$, $W_h \\in \\mathbb{R}^{H\\times 4H}$ so that activations $A \\in \\mathbb{R}^{N\\times 4H}$ can be computed efficiently as $A = X_t W_x + H_{t-1} W_h$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM: step forward\n",
    "Implement the forward pass for a single timestep of an LSTM in the `lstm_step_forward` function in the file `cs231n/rnn_layers.py`. This should be similar to the `rnn_step_forward` function that you implemented above, but using the LSTM update rule instead.\n",
    "\n",
    "Once you are done, run the following to perform a simple test of your implementation. You should see errors on the order of `e-8` or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "next_h error:  5.7054131185818695e-09\n",
      "next_c error:  5.8143123088804145e-09\n"
     ]
    }
   ],
   "source": [
    "N, D, H = 3, 4, 5\n",
    "x = np.linspace(-0.4, 1.2, num=N*D).reshape(N, D)\n",
    "prev_h = np.linspace(-0.3, 0.7, num=N*H).reshape(N, H)\n",
    "prev_c = np.linspace(-0.4, 0.9, num=N*H).reshape(N, H)\n",
    "Wx = np.linspace(-2.1, 1.3, num=4*D*H).reshape(D, 4 * H)\n",
    "Wh = np.linspace(-0.7, 2.2, num=4*H*H).reshape(H, 4 * H)\n",
    "b = np.linspace(0.3, 0.7, num=4*H)\n",
    "\n",
    "next_h, next_c, cache = lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)\n",
    "\n",
    "expected_next_h = np.asarray([\n",
    "    [ 0.24635157,  0.28610883,  0.32240467,  0.35525807,  0.38474904],\n",
    "    [ 0.49223563,  0.55611431,  0.61507696,  0.66844003,  0.7159181 ],\n",
    "    [ 0.56735664,  0.66310127,  0.74419266,  0.80889665,  0.858299  ]])\n",
    "expected_next_c = np.asarray([\n",
    "    [ 0.32986176,  0.39145139,  0.451556,    0.51014116,  0.56717407],\n",
    "    [ 0.66382255,  0.76674007,  0.87195994,  0.97902709,  1.08751345],\n",
    "    [ 0.74192008,  0.90592151,  1.07717006,  1.25120233,  1.42395676]])\n",
    "\n",
    "print('next_h error: ', rel_error(expected_next_h, next_h))\n",
    "print('next_c error: ', rel_error(expected_next_c, next_c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM: step backward\n",
    "Implement the backward pass for a single LSTM timestep in the function `lstm_step_backward` in the file `cs231n/rnn_layers.py`. Once you are done, run the following to perform numeric gradient checking on your implementation. You should see errors on the order of `e-7` or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  6.141307149471403e-10\n",
      "dh error:  3.3953235055372503e-10\n",
      "dc error:  1.5221723979041107e-10\n",
      "dWx error:  1.6933643922734908e-09\n",
      "dWh error:  2.5561308517943814e-08\n",
      "db error:  1.7349247160222088e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "N, D, H = 4, 5, 6\n",
    "x = np.random.randn(N, D)\n",
    "prev_h = np.random.randn(N, H)\n",
    "prev_c = np.random.randn(N, H)\n",
    "Wx = np.random.randn(D, 4 * H)\n",
    "Wh = np.random.randn(H, 4 * H)\n",
    "b = np.random.randn(4 * H)\n",
    "\n",
    "next_h, next_c, cache = lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)\n",
    "\n",
    "dnext_h = np.random.randn(*next_h.shape)\n",
    "dnext_c = np.random.randn(*next_c.shape)\n",
    "\n",
    "fx_h = lambda x: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fh_h = lambda h: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fc_h = lambda c: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fWx_h = lambda Wx: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fWh_h = lambda Wh: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fb_h = lambda b: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "\n",
    "fx_c = lambda x: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fh_c = lambda h: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fc_c = lambda c: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fWx_c = lambda Wx: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fWh_c = lambda Wh: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fb_c = lambda b: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "\n",
    "num_grad = eval_numerical_gradient_array\n",
    "\n",
    "dx_num = num_grad(fx_h, x, dnext_h) + num_grad(fx_c, x, dnext_c)\n",
    "dh_num = num_grad(fh_h, prev_h, dnext_h) + num_grad(fh_c, prev_h, dnext_c)\n",
    "dc_num = num_grad(fc_h, prev_c, dnext_h) + num_grad(fc_c, prev_c, dnext_c)\n",
    "dWx_num = num_grad(fWx_h, Wx, dnext_h) + num_grad(fWx_c, Wx, dnext_c)\n",
    "dWh_num = num_grad(fWh_h, Wh, dnext_h) + num_grad(fWh_c, Wh, dnext_c)\n",
    "db_num = num_grad(fb_h, b, dnext_h) + num_grad(fb_c, b, dnext_c)\n",
    "\n",
    "dx, dh, dc, dWx, dWh, db = lstm_step_backward(dnext_h, dnext_c, cache)\n",
    "\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dh error: ', rel_error(dh_num, dh))\n",
    "print('dc error: ', rel_error(dc_num, dc))\n",
    "print('dWx error: ', rel_error(dWx_num, dWx))\n",
    "print('dWh error: ', rel_error(dWh_num, dWh))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM: forward\n",
    "In the function `lstm_forward` in the file `cs231n/rnn_layers.py`, implement the `lstm_forward` function to run an LSTM forward on an entire timeseries of data.\n",
    "\n",
    "When you are done, run the following to check your implementation. You should see an error on the order of `e-7` or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h error:  8.610537452106624e-08\n"
     ]
    }
   ],
   "source": [
    "N, D, H, T = 2, 5, 4, 3\n",
    "x = np.linspace(-0.4, 0.6, num=N*T*D).reshape(N, T, D)\n",
    "h0 = np.linspace(-0.4, 0.8, num=N*H).reshape(N, H)\n",
    "Wx = np.linspace(-0.2, 0.9, num=4*D*H).reshape(D, 4 * H)\n",
    "Wh = np.linspace(-0.3, 0.6, num=4*H*H).reshape(H, 4 * H)\n",
    "b = np.linspace(0.2, 0.7, num=4*H)\n",
    "\n",
    "h, cache = lstm_forward(x, h0, Wx, Wh, b)\n",
    "\n",
    "expected_h = np.asarray([\n",
    " [[ 0.01764008,  0.01823233,  0.01882671,  0.0194232 ],\n",
    "  [ 0.11287491,  0.12146228,  0.13018446,  0.13902939],\n",
    "  [ 0.31358768,  0.33338627,  0.35304453,  0.37250975]],\n",
    " [[ 0.45767879,  0.4761092,   0.4936887,   0.51041945],\n",
    "  [ 0.6704845,   0.69350089,  0.71486014,  0.7346449 ],\n",
    "  [ 0.81733511,  0.83677871,  0.85403753,  0.86935314]]])\n",
    "\n",
    "print('h error: ', rel_error(expected_h, h))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM: backward\n",
    "Implement the backward pass for an LSTM over an entire timeseries of data in the function `lstm_backward` in the file `cs231n/rnn_layers.py`. When you are done, run the following to perform numeric gradient checking on your implementation. You should see errors on the order of `e-8` or less. (For `dWh`, it's fine if your error is on the order of `e-6` or less)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  7.251275328345264e-09\n",
      "dh0 error:  1.2273364018309013e-09\n",
      "dWx error:  2.3108350319316903e-09\n",
      "dWh error:  8.640836456498202e-07\n",
      "db error:  6.153728370623302e-10\n"
     ]
    }
   ],
   "source": [
    "from cs231n.rnn_layers import lstm_forward, lstm_backward\n",
    "np.random.seed(231)\n",
    "\n",
    "N, D, T, H = 2, 3, 10, 6\n",
    "\n",
    "x = np.random.randn(N, T, D)\n",
    "h0 = np.random.randn(N, H)\n",
    "Wx = np.random.randn(D, 4 * H)\n",
    "Wh = np.random.randn(H, 4 * H)\n",
    "b = np.random.randn(4 * H)\n",
    "\n",
    "out, cache = lstm_forward(x, h0, Wx, Wh, b)\n",
    "\n",
    "dout = np.random.randn(*out.shape)\n",
    "\n",
    "dx, dh0, dWx, dWh, db = lstm_backward(dout, cache)\n",
    "\n",
    "fx = lambda x: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "fh0 = lambda h0: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "fWx = lambda Wx: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "fWh = lambda Wh: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "fb = lambda b: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "dh0_num = eval_numerical_gradient_array(fh0, h0, dout)\n",
    "dWx_num = eval_numerical_gradient_array(fWx, Wx, dout)\n",
    "dWh_num = eval_numerical_gradient_array(fWh, Wh, dout)\n",
    "db_num = eval_numerical_gradient_array(fb, b, dout)\n",
    "\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dh0 error: ', rel_error(dh0_num, dh0))\n",
    "print('dWx error: ', rel_error(dWx_num, dWx))\n",
    "print('dWh error: ', rel_error(dWh_num, dWh))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "# INLINE QUESTION\n",
    "\n",
    "Recall that in an LSTM the input gate $i$, forget gate $f$, and output gate $o$ are all outputs of a sigmoid function. Why don't we use the ReLU activation function instead of sigmoid to compute these values? Explain.\n",
    "\n",
    "**Your Answer:** \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM captioning model\n",
    "\n",
    "Now that you have implemented an LSTM, update the implementation of the `loss` method of the `CaptioningRNN` class in the file `cs231n/classifiers/rnn.py` to handle the case where `self.cell_type` is `lstm`. This should require adding less than 10 lines of code.\n",
    "\n",
    "Once you have done so, run the following to check your implementation. You should see a difference on the order of `e-10` or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:  9.824459354432264\n",
      "expected loss:  9.82445935443\n",
      "difference:  2.2648549702353193e-12\n"
     ]
    }
   ],
   "source": [
    "N, D, W, H = 10, 20, 30, 40\n",
    "word_to_idx = {'<NULL>': 0, 'cat': 2, 'dog': 3}\n",
    "V = len(word_to_idx)\n",
    "T = 13\n",
    "\n",
    "model = CaptioningRNN(word_to_idx,\n",
    "          input_dim=D,\n",
    "          wordvec_dim=W,\n",
    "          hidden_dim=H,\n",
    "          cell_type='lstm',\n",
    "          dtype=np.float64)\n",
    "\n",
    "# Set all model parameters to fixed values\n",
    "for k, v in model.params.items():\n",
    "  model.params[k] = np.linspace(-1.4, 1.3, num=v.size).reshape(*v.shape)\n",
    "\n",
    "features = np.linspace(-0.5, 1.7, num=N*D).reshape(N, D)\n",
    "captions = (np.arange(N * T) % V).reshape(N, T)\n",
    "\n",
    "loss, grads = model.loss(features, captions)\n",
    "expected_loss = 9.82445935443\n",
    "\n",
    "print('loss: ', loss)\n",
    "print('expected loss: ', expected_loss)\n",
    "print('difference: ', abs(loss - expected_loss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overfit LSTM captioning model\n",
    "Run the following to overfit an LSTM captioning model on the same small dataset as we used for the RNN previously. You should see a final loss less than 0.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "base dir  E:\\internship\\code\\cs231n\\assignment3_jupyter\\assignment3\\cs231n\\datasets/coco_captioning\n",
      "(Iteration 1 / 100) loss: 79.551150\n",
      "(Iteration 11 / 100) loss: 43.829102\n",
      "(Iteration 21 / 100) loss: 30.062625\n",
      "(Iteration 31 / 100) loss: 14.020125\n",
      "(Iteration 41 / 100) loss: 6.004852\n",
      "(Iteration 51 / 100) loss: 1.849777\n",
      "(Iteration 61 / 100) loss: 0.642370\n",
      "(Iteration 71 / 100) loss: 0.286054\n",
      "(Iteration 81 / 100) loss: 0.236642\n",
      "(Iteration 91 / 100) loss: 0.126715\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "small_data = load_coco_data(max_train=50)\n",
    "\n",
    "small_lstm_model = CaptioningRNN(\n",
    "          cell_type='lstm',\n",
    "          word_to_idx=data['word_to_idx'],\n",
    "          input_dim=data['train_features'].shape[1],\n",
    "          hidden_dim=512,\n",
    "          wordvec_dim=256,\n",
    "          dtype=np.float32,\n",
    "        )\n",
    "\n",
    "small_lstm_solver = CaptioningSolver(small_lstm_model, small_data,\n",
    "           update_rule='adam',\n",
    "           num_epochs=50,\n",
    "           batch_size=25,\n",
    "           optim_config={\n",
    "             'learning_rate': 5e-3,\n",
    "           },\n",
    "           lr_decay=0.995,\n",
    "           verbose=True, print_every=10,\n",
    "         )\n",
    "\n",
    "small_lstm_solver.train()\n",
    "\n",
    "# Plot the training losses\n",
    "plt.plot(small_lstm_solver.loss_history)\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training loss history')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print final training loss. You should see a final loss of less than 0.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "id": "lstm_final_training_loss"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final loss:  0.08148875017955788\n"
     ]
    }
   ],
   "source": [
    "print('Final loss: ', small_lstm_solver.loss_history[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM test-time sampling\n",
    "Modify the `sample` method of the `CaptioningRNN` class to handle the case where `self.cell_type` is `lstm`. This should take fewer than 10 lines of code.\n",
    "\n",
    "When you are done run the following to sample from your overfit LSTM model on some training and validation set samples. As with the RNN, training results should be very good, and validation results probably won't make a lot of sense (because we're overfitting)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<http.client.HTTPResponse object at 0x0000028991D5FDC8>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<http.client.HTTPResponse object at 0x0000028991D5F688>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "URL Error:  Gone http://farm3.staticflickr.com/2759/4384863625_bfb01d9665_z.jpg\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "Image data cannot be converted to float",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-73-adabb6623a5b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mgt_caption\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_caption\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0murl\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgt_captions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_captions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0murls\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m         \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimage_from_url\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0murl\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m         \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'%s\\n%s\\nGT:%s'\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0msplit\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_caption\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgt_caption\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m         \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'off'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\matplotlib\\pyplot.py\u001b[0m in \u001b[0;36mimshow\u001b[1;34m(X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, shape, filternorm, filterrad, imlim, resample, url, data, **kwargs)\u001b[0m\n\u001b[0;32m   2697\u001b[0m         \u001b[0mfilternorm\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfilternorm\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfilterrad\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfilterrad\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mimlim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mimlim\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2698\u001b[0m         resample=resample, url=url, **({\"data\": data} if data is not\n\u001b[1;32m-> 2699\u001b[1;33m         None else {}), **kwargs)\n\u001b[0m\u001b[0;32m   2700\u001b[0m     \u001b[0msci\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m__ret\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2701\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0m__ret\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\matplotlib\\__init__.py\u001b[0m in \u001b[0;36minner\u001b[1;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1808\u001b[0m                         \u001b[1;34m\"the Matplotlib list!)\"\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mlabel_namer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1809\u001b[0m                         RuntimeWarning, stacklevel=2)\n\u001b[1;32m-> 1810\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0max\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1811\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1812\u001b[0m         inner.__doc__ = _add_data_doc(inner.__doc__,\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\matplotlib\\axes\\_axes.py\u001b[0m in \u001b[0;36mimshow\u001b[1;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, shape, filternorm, filterrad, imlim, resample, url, **kwargs)\u001b[0m\n\u001b[0;32m   5492\u001b[0m                               resample=resample, **kwargs)\n\u001b[0;32m   5493\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 5494\u001b[1;33m         \u001b[0mim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   5495\u001b[0m         \u001b[0mim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_alpha\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   5496\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_clip_path\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\matplotlib\\image.py\u001b[0m in \u001b[0;36mset_data\u001b[1;34m(self, A)\u001b[0m\n\u001b[0;32m    632\u001b[0m         if (self._A.dtype != np.uint8 and\n\u001b[0;32m    633\u001b[0m                 not np.can_cast(self._A.dtype, float, \"same_kind\")):\n\u001b[1;32m--> 634\u001b[1;33m             \u001b[1;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Image data cannot be converted to float\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    635\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    636\u001b[0m         if not (self._A.ndim == 2\n",
      "\u001b[1;31mTypeError\u001b[0m: Image data cannot be converted to float"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for split in ['train', 'val']:\n",
    "    minibatch = sample_coco_minibatch(small_data, split=split, batch_size=2)\n",
    "    gt_captions, features, urls = minibatch\n",
    "    gt_captions = decode_captions(gt_captions, data['idx_to_word'])\n",
    "\n",
    "    sample_captions = small_lstm_model.sample(features)\n",
    "    sample_captions = decode_captions(sample_captions, data['idx_to_word'])\n",
    "\n",
    "    for gt_caption, sample_caption, url in zip(gt_captions, sample_captions, urls):\n",
    "        plt.imshow(image_from_url(url))\n",
    "        plt.title('%s\\n%s\\nGT:%s' % (split, sample_caption, gt_caption))\n",
    "        plt.axis('off')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  },
  "nbdime-conflicts": {
   "local_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "key": 0,
         "length": 1,
         "op": "removerange"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ],
   "remote_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "diff": [
          {
           "key": 4,
           "op": "addrange",
           "valuelist": "7"
          },
          {
           "key": 4,
           "length": 1,
           "op": "removerange"
          }
         ],
         "key": 0,
         "op": "patch"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ]
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
